Galileo Computing < openbook > Galileo Computing - Professionelle Bücher. Auch für Einsteiger.

...powered by www.netzwerkartist.de...

 <<   zurück
Visual Basic 2005 von Andreas Kühnel
Das umfassende Handbuch
Buch: Visual Basic 2005

Visual Basic 2005
1.233 S., mit 2 CDs, 59,90 Euro
Galileo Computing
ISBN 3-89842-585-1
gp Kapitel 3 Grundlagen der Sprachsyntax
  gp 3.1 Konsolenanwendungen
    gp 3.1.1 Der Projekttyp Konsolenanwendung
    gp 3.1.2 Die Vorlage »Konsolenanwendung«
  gp 3.2 Variablen und Datentypen
    gp 3.2.1 Explizite und implizite Variablendeklaration
    gp 3.2.2 Die Variablendeklaration
    gp 3.2.3 Die einfachen Datentypen
    gp 3.2.4 Sichtbarkeit und Lebensdauer
    gp 3.2.5 Initialisierung von Variablen
    gp 3.2.6 Datentypkonvertierung
    gp 3.2.7 Ein- und Ausgabemethoden der Klasse »Console«
    gp 3.2.8 Zusammenfassung
  gp 3.3 Datenfelder (Arrays)
    gp 3.3.1 Eindimensionale Arrays
    gp 3.3.2 Mehrdimensionale Arrays
    gp 3.3.3 Ändern der Array-Kapazität
    gp 3.3.4 Initialisierung der Array-Elemente
    gp 3.3.5 Bestimmung der Array-Obergrenze
    gp 3.3.6 Zusammenfassung
  gp 3.4 Operatoren
    gp 3.4.1 Arithmetische Operatoren
    gp 3.4.2 Relationale Operatoren
    gp 3.4.3 Logische Operatoren
    gp 3.4.4 Zuweisungsoperatoren
    gp 3.4.5 Verkettungsoperator
    gp 3.4.6 Operatorprioritäten
    gp 3.4.7 Bitweise Operationen
    gp 3.4.8 Zusammenfassung
  gp 3.5 Kontrollstrukturen
    gp 3.5.1 Die If-Anweisung
    gp 3.5.2 »Select-Case«-Anweisung
    gp 3.5.3 Einzeilige Entscheidungsanweisungen
    gp 3.5.4 Zusammenfassung
  gp 3.6 Programmschleifen
    gp 3.6.1 Die For-Next-Schleife
    gp 3.6.2 Do-Loop-Schleifen
    gp 3.6.3 Die While-/End While-Schleife
    gp 3.6.4 Zusammenfassung


Galileo Computing

3.4 Operatoren  downtop

Im vorhergehenden Abschnitt haben wir uns eingehend mit den Daten auseinander gesetzt. Nun werden Sie lernen, wie diese Daten mit Visual Basic 2005 verarbeitet werden können. Bevor wir uns an die Details begeben, müssen wir uns zunächst mit der Terminologie beschäftigen, die im weiteren Verlauf von Bedeutung ist.

An oberster Stelle steht der Begriff Ausdruck. Ein Ausdruck ist die kleinste ausführbare Einheit eines Programms und setzt mindestens einen Operator voraus. Im einfachsten Fall gilt schon die Anweisung


intVar = 22

als Ausdruck. Ein Ausdruck wird immer aus mindestens einem Operanden und einem Operator gebildet. Der Operator im Beispiel oben ist das Gleichheitszeichen, als Operand gilt sowohl die Konstante 22 als auch die Variable intVar. Operatoren verknüpfen Operanden miteinander und führen Berechnungen durch, ermitteln also als Ergebnis der Operation neue Werte. Nahezu alle Operatoren benötigen zwei Operanden.

Kernkonstrukt von Ausdrücken sind die Operatoren, die sich entsprechend ihrer Arbeitsweise in verschiedene Gruppen aufteilen lassen:

gp  Arithmetische Operatoren
gp  Relationale Operatoren (Vergleichsoperatoren)
gp  Logische Operatoren
gp  Zuweisungsoperatoren
gp  Sonstige Operatoren

Galileo Computing

3.4.1 Arithmetische Operatoren  downtop

Visual Basic kennt die üblichen Operatoren der vier Grundrechenarten Addition, Subtraktion, Division und Multiplikation. Darüber hinaus werden von dieser Gruppe noch vier weitere Operatoren beschrieben, die in ihrem Kontext eine besondere Bedeutung haben. Die folgende Tabelle gibt zunächst einen allgemeinen Überblick.


Tabelle 3.6     Arithmetische Operatoren

Operator Beschreibung
+ Additionsoperator, bildet die Summe zweier Operanden (x + y)
hat zwei Funktionalitäten: als Subtraktionsoperator eingesetzt bildet er die Differenz zweier Operanden (x – y) als Vorzeichenoperator beschreibt er eine negative Zahl (–x), ist also ein einstelliger Präfixoperator
* Multiplikationsoperator, multipliziert zwei Operanden (x * y)
/ Divisionsoperator, dividiert zwei Operanden (x/y), behält den Nachkommateil der Division
\ Divisionsoperator, dividiert zwei Operanden und liefert nur den ganzzahligen Anteil der Division (x\y)
Mod Restwertoperator, dividiert zwei Operanden und liefert als Ergebnis den Restwert der Operation (x Mod y)
^ Potenzoperator, potenziert eine Zahl mit einem Exponenten

Der Einsatz der ersten vier Operatoren zur Formulierung mathematischer Ausdrücke ist trivial. Zwei Operanden werden miteinander verknüpft und das Ergebnis der Operation der links vom Zuweisungsoperator stehenden Variablen zugewiesen.


Dim srtResult As Short
Dim srtVar1 As Short = 30
Dim srtVar2 As Short = 55
srtResult = srtVar1 + srtVar2

In der Tabelle 3.6 sind drei verschiedene Divisionsoperatoren aufgeführt. Machen wir uns an einem Beispiel den Unterschied deutlich. Im folgenden Codefragment werden zwei Divisionen durchgeführt, eine auf Basis des Operators »/«, der den Nachkommaanteil im Ergebnis behält, die andere setzt mit denselben Operanden den Operator »\« ein. Das Ergebnis beider Berechnungen wird wieder an der Konsole ausgegeben.


Dim x As Integer = 100
Dim y As Integer = 17
Console.WriteLine("Division mit \ – Ergebnis = {0}", x \ y)
Console.WriteLine("Division mit / – Ergebnis = {0}", x / y)

Die Ausgabe wird lauten:


Division mit \ – Ergebnis = 5
Division mit / – Ergebnis = 5,882352941176471

Beachten Sie insbesondere, dass der Nachkommateil der ersten Division abgeschnitten und nicht gerundet wird.

Die besondere Stellung des Mod-Operators ist dadurch gekennzeichnet, dass das Ergebnis dieser Division der ganzzahlige Rest ist. Dazu ein Beispiel:


Dim x As Integer = 100
Dim y As Integer = 17
Console.WriteLine("Division mit Mod-Ergebnis = {0}", x Mod y)

Die Zahl 17 lässt sich fünfmal in die Zahl 100 stecken (für diejenigen, deren Ausbildungsziel der Hochschulreife schon länger als zwei Jahre zurückliegt, der mathematische Beweis: 5 * 17 = 85), als Rest verbleibt danach 15, der an der Konsole ausgegeben wird.

Dezimalzahlen als Operanden sind ebenfalls zugelassen, die Rückgabe ist eine Dezimalzahl:


Dim x As Single = 100.35
Dim y As Single = 17.45
Console.WriteLine("Division mit Mod-Ergebnis = {0}", x Mod y)

Führen Sie diesen Code aus, wird im Konsolenfenster die Ausgabe 13,0999 erscheinen.


Galileo Computing

3.4.2 Relationale Operatoren  downtop

Relationale Operatoren vergleichen zwei Ausdrücke miteinander. Der Rückgabewert ist immer ein Boolean, also entweder True oder False. Vergleiche können auf Gleichheit bzw. Ungleichheit sowie auf größer und kleiner durchgeführt werden.


Tabelle 3.7     Vergleichsoperatoren

Operator Beschreibung
a = b (Vergleichsoperator) prüft, ob der Ausdruck a dem Ausdruck b entspricht und gibt in diesem Fall True zurück
a <> b Ergebnis der Operation ist True, wenn a ungleich b ist
a > b Ergebnis der Operation ist True, wenn a größer b ist
a < b Ergebnis der Operation ist True, wenn a kleiner b ist
a <= b Ergebnis der Operation ist True, wenn a kleiner oder gleich b ist

a >= b

Ergebnis der Operation ist True, wenn a größer oder gleich b ist
Like vergleicht eine gegebene Zeichenfolge mit einer zweiten oder einer Mustervorgabe
Is vergleicht zwei Objekte miteinander und liefert True, wenn beide Objekte gleich sind
IsNot vergleicht zwei Objekte miteinander und liefert True, wenn beide Objekte nicht gleich sind
TypeOf...Is prüft ein Objekt auf einen bestimmten Typen

Das Gleichheitszeichen dient als Zuweisungs- und als Vergleichsoperator. Welche Funktionalität ihm dabei zukommt, ergibt sich nur aus dem Kontext. Der Vergleichsoperator Like dient speziell dazu, zwei Zeichenfolgen miteinander zu vergleichen.


Dim bolStr As Boolean
bolStr = "Hallo" Like "hallo"

Das Ergebnis des Vergleichs wird False sein, weil sich die beiden Zeichenfolgeliterale im ersten Buchstaben unterscheiden. Visual Basic unterscheidet standardmäßig zwei Zeichenfolgen auf binärer Basis, differenziert also zwischen der Groß- und Kleinschreibung. Diese Standardvorgabe kann über einen Optionsschalter so verändert werden, dass nur noch ein textbasierender Vergleich erfolgt. Dazu wird außerhalb des Moduls Option Compare Text angegeben, was sich nur auf das aktuelle Modul auswirkt. Der Schalter kann auch im Projekteigenschaftsfenster gesetzt werden, was sich dann anwendungsweit auswirkt. Die Standardeinstellung dieses Optionsschalters lautet Option Compare Binary.

Der Operator Like geht in seinen Möglichkeiten aber noch deutlich weiter: Es kann auch eine Zeichenfolge mit einem Zeichenfolgemuster verglichen werden. In einem definierten Muster können Sie Platzhalter, Zeichenlisten und Zeichenbereiche in vielfältiger Kombination verwenden.


Tabelle 3.8     Zeichen zur Beschreibung eines Zeichenfolgemusters

Zeichen Beschreibung
? Dient als Platzhalter für genau ein beliebiges Zeichen in einer Zeichenfolge.
* Dient als Platzhalter für kein oder mehrere Zeichen in einer Zeichenfolge.
# Dient als Platzhalter für eine Ziffer im Bereich 0 – 9
[<Zeichenliste>] Formuliert einen Zeichenbereich für ein gesuchtes Zeichen in einer Zeichenfolge.
[!<Zeichenliste>] Formuliert einen ausschließenden Zeichenbereich für ein gesuchtes Zeichen in einer Zeichenfolge.

Dazu einige Beispiele:


'die folgenden Ausdrücke liefern alle "True"
bolVar = "Hallo" Like "*al*"
bolVar = "VB7" Like "VB#"
bolVar = "7Uhr" Like "#[P-U][!c-e]*"

Unterziehen wir das letzte Beispiel einer genaueren Analyse. Das Zeichenfolgemuster des rechten Operanden verlangt durch # eine Ziffer an der ersten Position der Zeichenfolge. Durch die Zahl 7 wird diese Bedingung erfüllt. An zweiter Position muss ein Zeichen stehen, das sich im Bereich zwischen einschließlich P und U bewegen muss. Auch diese Bedingung kann erfüllt werden. Das dritte Zeichen wiederum darf kein Zeichen zwischen c und e sein – hier befindet sich der Buchstabe h im Vergleichsstring. Der Rest der Zeichenfolge kann in jeder Hinsicht beliebig sein. Damit steht fest, »7Uhr« erfüllt die Auflagen des Zeichenfolgemusters.

Vergleiche sind nicht nur auf einfache numerische Ausdrücke begrenzt. Es können auch zwei Objekte miteinander verglichen werden. Dafür ist aber das Gleichheitszeichen denkbar ungeeignet, deshalb wurde der Is-Operator eingeführt. Manchmal ist es auch von Interesse, ein Objekt auf seinen Typ zu prüfen. Dazu ist der Vergleichsoperator TypeOf...Is spezifiziert.


Galileo Computing

3.4.3 Logische Operatoren  downtop

Logische Operatoren verbinden zwei Wahrheitswerte miteinander, um daraus einen neuen gültigen Wahrheitswert zu ermitteln. Die Operanden der logischen Operation können sowohl Werte darstellen als auch aus Vergleichsoperationen gebildet werden.

In der Datenverarbeitung spricht man von:

gp  True, wenn ein Vergleich zutrifft, also wahr ist
gp  False, wenn der Vergleich nicht zutrifft, also falsch ist

Tabelle 3.9     Logische Operatoren

Operator Beschreibung
And Das Ergebnis der Operation ist nur dann True, wenn beide Operanden True sind. Beide am Vergleich beteiligten Operanden werden geprüft.
Or Das Ergebnis der Operation ist genau dann True, wenn mindestens einer der beiden Operanden True ist. Beide am Vergleich beteiligten Operanden werden geprüft.
Xor Das Ergebnis der Operation ist nur dann True, wenn beide Operanden unterschiedliche Wahrheitswerte haben
AndAlso Basiert auf dem And-Operator. Liefert der erste Operand False, wird der Wahrheitswert des zweiten nicht mehr überprüft.
OrElse Basiert auf dem Or-Operator. Liefert der erste Operand True, wird der Wahrheitswert des zweiten nicht mehr überprüft.
Not Logische Negation. Kehrt einen Wahrheitswert um.

Das Ergebnis einer Operation, an dem logische Operatoren beteiligt sind, lässt sich am besten anhand von Wahrheitstabellen darstellen.


Tabelle 3.10     Wahrheitstabellen

Bedingung 1 Bedingung 2 And Or Xor
False False False False False
True False False True True
False True False True True
True True True True False

Beachten Sie bitte, dass es sich bei Operanden tatsächlich um Ausdrücke handelt, die boolesche Werte repräsentieren. Daher führt die folgende Anweisung zu einer Fehlermeldung:


'unzulässige boolesche Operation
Dim bolVar As Boolean
bolVar = 1 And 2

Beide Literale werden als Integer behandelt, die nicht implizit in einen Boolean konvertiert werden können. Zur Lösung dieses Problems muss jedes Literal explizit in einen Boolean konvertiert werden:


Dim bolVar As Boolean
bolVar = CBool(1) And CBool(0)

Eine gültige boolesche Operation wäre beispielsweise:


x < 10 And y >= 12

Das Ergebnis ist nur dann True, wenn x eine Zahl kleiner 10 ist und gleichzeitig y entweder größer oder gleich der Zahl 12 ist. Alle anderen Fälle gelten als False.

Betrachten wir noch einmal das obige Beispiel. Der gesamte Ausdruck kann nur dann True werden, wenn schon die erste Bedingung x < 10 True liefert. Ist x größer oder gleich 10, kann der Gesamtausdruck niemals wahr sein. Interessant ist nun die Frage, wie Visual Basic reagiert, wenn schon die erste Bedingung falsch ist. Wird der zweite Teilsausdruck noch ausgewertet, oder wird auf die zweite Bedingungsprüfung dann generell verzichtet?

Um diese Frage zu beantworten, werden zu Testzwecken zwei benutzerdefinierte Funktionen entwickelt. Funktionen ähneln den Prozeduren mit dem Unterschied, dass sie einen Rückgabewert liefern. Der Funktionsaufruf in der logischen Operation wird nach der Ausführung durch den Rückgabewert ersetzt. Im Beispielcode unten liefern die beiden Funktionen FirstCondition und SecondCondition einen Boolean als Ergebnis des Aufrufs zurück.


' ----------------------------------------------------
' Beispiel: ...\Kapitel 3\And_Operator
' ---------------------------------------------------
Module Module1
Sub Main()
Dim bolVar As Boolean
bolVar = FirstCondition() And SecondCondition()
Console.Read()
End Sub
Public Function FirstCondition() As Boolean
Console.WriteLine("Aufruf FirstCondition")
Return False
End Function
Public Function SecondCondition() As Boolean
Console.WriteLine("Aufruf SecondCondition")
Return True
End Function
End Module

Der Rückgabewert der erstgenannten Funktion FirstCondition ist statisch und immer False, der der zweiten Funktion immer True. In der Codezeile


bolVar = FirstCondition() And SecondCondition()

werden beide Funktionen aufgerufen, obwohl nach der Ausführung von FirstCondition bereits feststeht, dass das Ergebnis des zweiten Funktionsaufrufs keinen Einfluss mehr auf das Gesamtergebnis mehr haben wird: bolVar wird in jedem Fall False sein.

Nun sind zwei Situationen vorstellbar: Vielleicht muss die zweite Funktion SecondCondition unbedingt ausgeführt werden, beispielsweise um innerhalb der Funktion Aktionen auszuführen, die auf den weiteren Ablauf des Programms zur Laufzeit entscheidenden Einfluss haben. Dieser Fall wird durch unser Beispiel abgedeckt. Andererseits könnte es auch sein, dass man unbedingt den Aufruf der zweiten Funktion vermeiden möchte – vielleicht nur aus dem Grund heraus, die Ausführungsgeschwindigkeit des Programms zu verbessern.

Zu diesem Zweck bietet VB 2005 mit AndAlso einen logischen Operator an, der den booleschen Wert des ersten Operanden dazu benutzt festzustellen, ob der zweite Operand überhaupt noch die Chance hat, das Ergebnis der gesamten Operation zu beeinflussen.


Sub Main()
Dim bolVar As Boolean
bolVar = FirstCondition() AndAlso SecondCondition()
Console.Read()
End Sub

Die Ausgabe an der Konsole zeigt, dass es erst gar nicht zur Ausführung der zweiten Funktion kommt. Die Common Language Runtime (CLR) bricht die Ausführung nach dem Aufruf der ersten Funktion ab. Sie müssen sich darüber klar sein, dass in der rechts neben AndAlso aufgeführten Funktion niemals Code implementiert werden darf, der entscheidenden Einfluss auf die Logik des Gesamtprogramms hat.

Sehr ähnlich verhalten sich auch die Operatoren Or und OrElse. Dazu ändern wir das vorhergehende Beispiel And_Operator ein wenig ab.


' ----------------------------------------------------
' Beispiel: ...\Kapitel 3\Or_Operator
' ---------------------------------------------------
Module Module1
Sub Main()
Dim bolVar As Boolean
bolVar = FirstCondition() Or SecondCondition()
Console.Read()
End Sub
Public Function FirstCondition() As Boolean
Console.WriteLine("Aufruf FirstCondition")
Return True
End Function
Public Function SecondCondition() As Boolean
Console.WriteLine("Aufruf SecondCondition")
Return True
End Function
End Module

Der Aufruf der Funktion FirstCondition liefert diesmal True zurück. Demnach wird das Gesamtergebnis der logischen Operation in jedem Fall True sein, unabhängig vom Rückgabewert des Aufrufs der zweiten Funktion SecondCondition. Erlaubt die Programmlogik, auf den zweiten Aufruf zu verzichten, kann der Or-Operator durch OrElse ersetzt werden.

Mit dem Not-Operator lässt sich das Ergebnis einer logischen Operation umkehren:


Dim Zahl As Long
...
Dim bolValue As Boolean
bolValue = Not (Zahl > 5)

liefert dann True als Ergebnis der gesamten Operation, wenn Zahl gleich oder kleiner 5 ist.


Galileo Computing

3.4.4 Zuweisungsoperatoren  downtop

Das Angebot an Zuweisungsoperatoren unter VB 2005 hat sich, verglichen mit den Vorgängerversionen, drastisch erhöht. Die verkürzte Form einer Zuweisung ist nun mit nahezu allen arithmetischen Operatoren möglich.


Tabelle 3.11     Vergleichsoperatoren

Operator Beschreibung
= Mit x = y wird x der Wert von y zugewiesen.
+= Mit x += y wird zum aktuellen Inhalt von x der Inhalt von y addiert und das Ergebnis anschließend in x gespeichert.
–= Mit x –= y wird vom aktuellen Inhalt von x der Inhalt von y subtrahiert und das Ergebnis anschließend in x gespeichert.
*= Mit x *= y wird der aktuelle Inhalt von x mit dem von y multipliziert und anschließend in x gespeichert.
/= Mit x /= y wird der aktuelle Inhalt von x durch den Inhalt von y dividiert und anschließend in x gespeichert. Der Dezimalteil bleibt dabei erhalten.
\= Mit x \= y wird der aktuelle Inhalt von x durch den Inhalt von y dividiert und anschließend in x gespeichert. Der Nachkommateil wird ohne vorhergehende Rundung abgeschnitten.
^= Mit x ^= y wird der aktuelle Inhalt von x mit y potenziert und in x gespeichert.
&= Mit x &= y werden zwei Stringausdrücke verknüpft. Dabei wird dem aktuellen Inhalt des Strings x der Strings y angehängt und in x gespeichert.

Problematisch ist immer noch der einfache Zuweisungsoperator, der sich nicht vom Vergleichsoperator unterscheidet. Nur aus dem Kontext heraus erfolgt eine Unterscheidung. Der Ausdruck


a = b = c

weist nicht den Inhalt von c erst b zu und danach a, sondern


b = c

wird als Vergleich interpretiert, der einen booleschen Wert, also True bei Gleichheit oder False bei Ungleichheit, zurückliefert. Erst nach der Vergleichsoperation wird dessen Ergebnis der Variablen a zugewiesen, die vom Typ Boolean sein muss.

Die anderen Zuweisungsoperatoren sind verkürzte Formen der arithmetischen Operatoren. Dazu ein Beispiel:


intVar = intVar + 1

Der aktuelle Inhalt der Variablen intVar wird um 1 erhöht und das Ergebnis wiederum intVar zugewiesen. In der verkürzten Schreibweise könnte das auch durch


intVar += 1

ausgedrückt werden. Alle arithmetischen Ausdrücke werden durch diese neue Kurznotation erfasst.


Galileo Computing

3.4.5 Verkettungsoperator  downtop

Sie werden öfters in die Situation kommen, zwei oder mehr Strings zu einem einzigen zu verketten. Visual Basic bietet zu diesem Zweck zwei Operatoren an: »&« und »+«.


Dim strText1, strText2, strText3 As String
strText1 = "Visual Basic macht "
strText2 = "Spass"
strText3 = strText1 & strText2
Console.WriteLine(strText3)

Die beiden Zeichenfolgen strText1 und strText2 werden in strText3 zu einem String zusammengesetzt und dieser an der Eingabeaufforderung ausgegeben. Einer der beiden Operanden dürfte sogar eine Zahl sein, die bei der Verkettung mit & automatisch in einen String konvertiert wird.


'weist str "Gute N8" zu
str = "Gute N" & 8

Grundsätzlich können zwei Zeichenfolgen auch mit dem +-Operator verkettet werden. Ist einer der beiden Operanden jedoch eine Zahl, führt das zu einer Fehlermeldung der Entwicklungsumgebung.


'fehlerhafter Ausdruck
str = "Gute N" + 8

Der Additionsoperator versucht, eine Zeichenfolge und eine Zahl zu addieren. Dazu müsste der String in einen Double konvertiert werden, was nach allen bekannten Regeln natürlich nicht möglich ist.


Galileo Computing

3.4.6 Operatorprioritäten  downtop

Enthalten Ausdrücke mehrere Operatoren, stehen diese in einem bestimmten Prioritätsverhältnis zueinander. In der folgenden Tabelle ist dieser Sachverhalt wiedergegeben. Je weiter unten ein Operator in der Tabelle steht, desto geringer ist seine Priorität.


Tabelle 3.12     Operatorprioritäten

Operator Beschreibung
^ Exponentialoperator
hier: Negation
*, / Multiplikation, Division
\ ganzzahlige Division
Mod Restwertdivision
+, – Addition, Subtraktion
& Stringverkettungsoperator
=, <>, <, >, <=, >=, TypeOf ...Is, Is, Like Vergleichsoperatoren
Not Negationsoperator
And, AndAlso logisches Und
Or, Xor, OrElse logisches und exklusives Oder

Die Prioritätsregeln der Operatoren können durch entsprechende Klammerung aufgehoben werden. Geklammerte Teilausdrücke werden zuerst ausgewertet. Innerhalb der Teilausdrücke werden alle Operatoren gemäß ihrer Priorität behandelt. Falls Sie sich bei einigen Operatoren über die Priorität unsicher sind, dann sollten Sie sicherheitshalber Klammern verwenden, um die von Ihnen gewünschte Auswertungsreihenfolge sicherzustellen – Klammern haben nämlich immer höchste Priorität.

Zuweisungsoperatoren haben die geringste Priorität (Anmerkung: Beachten Sie bitte, dass der =-Operator in der Tabelle 3.12 als Vergleichs- und nicht als Zuweisungsoperator angegeben ist). Es gilt immer ganz allgemein: In einer Zuweisung wird generell der rechts vom Zuweisungsoperator stehende Ausdruck ausgewertet, bevor dann das Ergebnis der links stehenden Variablen zugewiesen wird.


Galileo Computing

3.4.7 Bitweise Operationen  downtop

Wenn Ihnen im Laufe der Zeit die Klassenbibliothek des .NET Frameworks immer vertrauter wird, werden Sie feststellen, dass viele Zustände durch die Bitstellung in einem einzelnen Byte, auch als Bitmaske bezeichnet, beschrieben werden.

Ein gutes Beispiel dafür ist die Erkennung, welche Tasten der Tastatur ein Anwender zur Laufzeit einer Windows-Anwendung gedrückt hat. Wie Sie wissen (sollten), können Sie über die Tastatur durch Tastenkombinationen das Verhalten einer Applikation steuern. In diesem Zusammenhang spielen insbesondere die Tasten (Alt), (Strg) und (Shift) eine wichtige Rolle. Wenn ein Programm beispielsweise auf die Tastenkombination (Alt) + (F1) anders reagieren soll als auf die Kombination (Alt) + (F3), muss es eine Möglichkeit geben herauszufinden, welche Tasten gleichzeitig gedrückt worden sind.

Probleme dieser Art werden häufig auf relativ einfache Art und Weise gelöst. Irgendwo in den Tiefen des Systems ist – entsprechend den Anforderungen – ein Byte reserviert (es können auch mehrere sein). Die gesetzten beziehungsweise ungesetzten Bits dieser Bitmaske beschreiben einen bestimmten, vordefinierten Zustand. Stellen wir uns dazu rein hypothetisch vor, es wäre die folgende Festlegung getroffen worden:


(Alt)-Taste 1001 0000
(Strg)-Taste 0000 1100
(Shift)-Taste 0100 0001

Es sei vom Programm ein Byte definiert, das beschreibt, ob und welche dieser drei Tasten gleichzeitig gedrückt sind. Bezeichnen wir dieses Byte im Folgenden als Tastatur-Byte. Enthält das Tastatur-Byte nur ungesetzte Bits (0000 0000), ist keine der drei Tasten gedrückt. Enthält das Tastatur-Byte 0100 1101, würde es die beiden gedrückten Tasten (Strg) und (Shift) beschreiben.

Per Programmcode muss zur Laufzeit die Bitstellung des Tatstatur-Bytes interpretiert werden. Hat der Anwender die (Alt)-Taste gedrückt oder eine andere oder gar eine Kombination? In Abhängigkeit davon führt das Programm vielleicht unterschiedliche Aktionen aus.

Grundsätzlich wird zur Lösung solcher Probleme der Or-Operator benutzt. Dazu wird der Inhalt des Tastatur-Bytes mit der definierten Bitstellung einer bestimmten Taste herangezogen. Beide werden mit dem Or-Operator verknüpft. Entspricht das Ergebnis der Bitmaske des Tastatur-Bytes, hat der Anwender die Taste gedrückt.

Dazu ein Beispiel. Wir stellen uns die Frage, ob die aktuelle Bitstellung der Bitmaske 1001 1100 auch die gedrückte Taste (Strg) beschreibt. Gehen Sie dazu wie folgt vor:


If <Tastatur-Byte> = (<Tastatur-Byte> Or <Strg>) Then ...

Wichtig ist, dass Sie die Klammern setzen, weil Sie ansonsten ein falsches Ergebnis erhalten. Bekanntlich hat das Gleichheitszeichen unter Visual Basic zwei Bedeutungen: Es wird sowohl als Zuweisungsoperator als auch als Vergleichsoperator eingesetzt. Innerhalb einer If-Bedingung wird es als Vergleichsoperator interpretiert und genießt damit dieselbe Priorität wie der Or-Operator. Setzen Sie keine Klammern, implementieren also


If <Tastatur-Byte> = <Tastatur-Byte> Or <Strg> ...

hätte das die Auswertung von links nach rechts zur Folge. Zuerst wird das Tastatur-Byte mit sich selbst verglichen. Das liefert in jedem Fall True zurück und wird damit, unabhängig vom rechten Operanden, grundsätzlich immer True für den gesamten Ausdruck sein. Sie müssen, um dieses zu vermeiden, zuerst das Tastatur-Byte mit der Bitstellung der Taste vergleichen und deshalb grundsätzlich die beiden Operanden des Or-Operators in Klammern setzen.

Die Bits 1001 1100 des Tastatur-Bytes beschreiben die Zahl 156, (Strg) wird durch die Zahl 12 repräsentiert. Damit können wir das folgende Codefragment schreiben:


' -----------------------------------------------------------
' Beispiel: ...\Kapitel 3\Or-Vergleich
' -----------------------------------------------------------
Module Module1
Sub Main()
Dim byteStrg As Byte = 12
Dim byteTastatur As Byte = 156
If byteTastatur = (byteTastatur Or byteStrg) Then
Console.WriteLine("Bitfolge enthalten")
Else
Console.WriteLine("Bitfolge nicht enthalten.")
End If
Console.ReadLine()
End Sub
End Module

An der Konsole wird von diesem Code


Bitfolge enthalten

ausgegeben.

Da Sie nun wissen, wie Sie eine Bitmaske auf eine bestimmte Bitkombination hin überprüfen, muss nun auch noch verraten werden, wie Sie bestimmte Bits setzen beziehungsweise auch wieder zurücksetzen können.

Zuerst das Setzen von Bits. Auch hierzu wird der Or-Operator benutzt:


byteTastatur = byteTastatur Or byteShift

Beachten Sie hierbei, dass im Gegensatz zu der If-Anweisung nun die Klammern nicht mehr Pflicht sind, da in dieser Anweisung das Gleichheitszeichen grundsätzlich immer als Zuweisungsoperator interpretiert wird. Als Zuweisungsoperator genießt das Gleichheitszeichen aber eine geringere Priorität als der Or-Operator. Demzufolge wird zuerst die Or-Verknüpfung ausgeführt und erst danach das Ergebnis der Bitmaske byteTastatur zugewiesen.

Nehmen wir nun an, die Variable byteTastatur repräsentiert die Bitkombination


1001 1100

Da gemäß den Wahrheitstabellen eine Or-Verknüpfung immer dann einen wahren Wert ergibt, wenn einer oder beide zu vergleichenden Operatoren wahr bzw. 1 ist bzw. sind, gilt:


byteTastatur = 156
byteShift = 65
byteTastatur = byteTastatur Or byteShift

Das Ergebnis lautet 221 und resultiert aus dem folgenden Bitvergleich:


1001 1100
Or 0100 0001
------------
1101 1101

Die resultierende Bitmaske beschreibt nun auch die gedrückte (Shift)-Taste.

Zum Abschluss wollen wir noch aus einer gegebenen Bitmaske eine bestimmte Bitkombination herausfiltern. Hier können wir uns des Xor-Operators bedienen. Es soll das zuvor gesetzte Bit der (Shift)-Taste nun aus der Bitmaske entfernt werden:


byteTastatur = byteTastatur Xor byteShift

Xor liefert als Ergebnis des Vergleichs dann einen wahren Wert, wenn genau einer der beiden beteiligten Operanden wahr ist. Schauen wir uns dazu wieder den direkten Bitvergleich an:


1101 1101
Xor 0100 0001
-------------
1001 1100

Nun beschreibt die Bitmaske wieder ihren ursprünglichen Wert. Wir haben alle die Bits, die in unserer Definition die gedrückte (Shift)-Taste beschreiben, in der Maske zurückgesetzt.


Galileo Computing

3.4.8 Zusammenfassung  toptop

gp  Arithmetische Operatoren werden für alle vier Grundrechenarten bereitgestellt sowie ein weiterer für die Potenzierung. Für die Division stehen insbesondere drei Operatoren zur Verfügung, die den Dezimalteil einer Division beibehalten, ihn abschneiden oder auch nur den ganzzahligen Rest der Operation liefern.
gp  Bei den mathematischen Operationen ist zu berücksichtigen, dass der Compiler Literale immer als Integer oder als Double interpretiert.
gp  Relationale Operatoren (Vergleichsoperatoren) vergleichen zwei Ausdrücke miteinander und liefern einen booleschen Wert.
gp  Logische Operatoren verbinden zwei Wahrheitswerte und liefern als Ergebnis wiederum einen Wahrheitswert zurück.
gp  Die Operatorpaare And und AndAlso sowie Or und OrElse unterscheiden sich im Prüfverhalten. Mit And und Or werden die beiden am Vergleich beteiligten Operanden in jedem Fall geprüft, mit AndAlso und OrElse wird auf die Prüfung des rechten Operanden verzichtet, wenn dessen Prüfergebnis keinen Einfluss auf das Resultat der gesamten Operation hat.
gp  Die Operatoren Or und Xor können sowohl für Vergleichs- als auch für bitweise Operationen eingesetzt werden.
gp  Das Gleichheitszeichen hat unter Visual Basic zwei Bedeutungen: Es dient als Zuweisungs- und als Vergleichsoperator. Innerhalb eines Ausdrucks, der einen Wahrheitwert zurückliefert, wird das Gleichheitszeichen als Vergleichsoperator interpretiert, ansonsten als Zuweisungsoperator. Nur aus dem syntaktischen Zusammenhang heraus lässt sich Funktionalität erkennen, die auch Konsequenzen hinsichtlich der Priorität nach sich zieht.
 <<   zurück
  
  Zum Katalog
Zum Katalog: Visual Basic 2005
Visual Basic 2005
bestellen
 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 Buchtipps
Zum Katalog: Visual C# 2005






 Visual C# 2005


Zum Katalog: Fortgeschrittene Programmierung mit Visual C# 2005






 Fortgeschrittene
 Programmierung
 mit Visual C# 2005


Zum Katalog: Das Programmierhandbuch SQL Server 2005






 Das Programmier-
 handbuch
 SQL Server 2005


Zum Katalog: Einstieg in Visual Basic 2005






 Einstieg in
 Visual Basic 2005


Zum Katalog: Einstieg in Visual C# 2005






 Einstieg in
 Visual C# 2005


Zum Katalog: Konzepte und Lösungen für Microsoft-Netzwerke






 Konzepte und
 Lösungen für
 Microsoft-Netzwerke


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo








Copyright © Galileo Press 2007
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.


[Galileo Computing]

Galileo Press, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, info@galileo-press.de